home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Tools / Languages / Icon 8.1 / msm-2 / iconc.sit / toktab.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-09-19  |  21.8 KB  |  600 lines  |  [TEXT/MPS ]
  1. /*
  2.  * NOTE, this file is generated automatically by mktoktab
  3.  *  from tokens.txt and op.txt.
  4.  */
  5. #include "::h:gsupport.h"
  6. #include "trans.h"
  7. #include "tree.h"
  8. #include "tcode.h"
  9. #include "tsym.h"
  10. #include "tlex.h"
  11. #include "token.h"
  12. #include "tproto.h"
  13.  
  14. /*
  15.  * Token table - contains an entry for each token type
  16.  * with printable name of token, token type, and flags
  17.  * for semicolon insertion.
  18.  */
  19.  
  20. struct toktab toktab[] = {
  21. /*  token        token type    flags */
  22.  
  23.    /* primitives */
  24.    "identifier",      IDENT,         Beginner+Ender,    /*   0 */
  25.    "integer-literal", INTLIT,        Beginner+Ender,    /*   1 */
  26.    "real-literal",    REALLIT,       Beginner+Ender,    /*   2 */
  27.    "string-literal",  STRINGLIT,     Beginner+Ender,    /*   3 */
  28.    "cset-literal",    CSETLIT,       Beginner+Ender,    /*   4 */
  29.    "end-of-file",     EOFX,          0,                 /*   5 */
  30.  
  31.    /* reserved words */
  32.    "break",           BREAK,         Beginner+Ender,    /*   6 */
  33.    "by",              BY,            0,                 /*   7 */
  34.    "case",            CASE,          Beginner,          /*   8 */
  35.    "create",          CREATE,        Beginner,          /*   9 */
  36.    "default",         DEFAULT,       Beginner,          /*  10 */
  37.    "do",              DO,            0,                 /*  11 */
  38.    "dynamic",         DYNAMIC,       Beginner,          /*  12 */
  39.    "else",            ELSE,          0,                 /*  13 */
  40.    "end",             END,           Beginner,          /*  14 */
  41.    "every",           EVERY,         Beginner,          /*  15 */
  42.    "fail",            FAIL,          Beginner+Ender,    /*  16 */
  43.    "global",          GLOBAL,        0,                 /*  17 */
  44.    "if",              IF,            Beginner,          /*  18 */
  45.    "initial",         INITIAL,       Beginner,          /*  19 */
  46.    "invocable",       INVOCABLE,     0,                 /*  20 */
  47.    "link",            LINK,          0,                 /*  21 */
  48.    "local",           LOCAL,         Beginner,          /*  22 */
  49.    "next",            NEXT,          Beginner+Ender,    /*  23 */
  50.    "not",             NOT,           Beginner,          /*  24 */
  51.    "of",              OF,            0,                 /*  25 */
  52.    "procedure",       PROCEDURE,     0,                 /*  26 */
  53.    "record",          RECORD,        0,                 /*  27 */
  54.    "repeat",          REPEAT,        Beginner,          /*  28 */
  55.    "return",          RETURN,        Beginner+Ender,    /*  29 */
  56.    "static",          STATIC,        Beginner,          /*  30 */
  57.    "suspend",         SUSPEND,       Beginner+Ender,    /*  31 */
  58.    "then",            THEN,          0,                 /*  32 */
  59.    "to",              TO,            0,                 /*  33 */
  60.    "until",           UNTIL,         Beginner,          /*  34 */
  61.    "while",           WHILE,         Beginner,          /*  35 */
  62.    "end-of-file",     0,             0,
  63.    };
  64.  
  65. /*
  66.  * restab[c] points to the first reserved word in toktab which
  67.  * begins with the letter c.
  68.  */
  69.  
  70. struct toktab *restab[] = {
  71. #if !EBCDIC
  72.    NULL,        &toktab[ 6], &toktab[ 8], &toktab[10], /* 61-64 abcd */
  73.    &toktab[13], &toktab[16], &toktab[17], NULL,        /* 65-68 efgh */
  74.    &toktab[18], NULL,        NULL,        &toktab[21], /* 69-6C ijkl */
  75.    NULL,        &toktab[23], &toktab[25], &toktab[26], /* 6D-70 mnop */
  76.    NULL,        &toktab[27], &toktab[30], &toktab[32], /* 71-74 qrst */
  77.    &toktab[34], NULL,        &toktab[35], NULL,        /* 75-78 uvwx */
  78.    NULL,        NULL,                                  /* 79-7A yz */
  79. #else                    /* EBCDIC */
  80.    NULL,        &toktab[ 6], &toktab[ 8], &toktab[10], /* 81-84 abcd */
  81.    &toktab[13], &toktab[16], &toktab[17], NULL,        /* 85-88 efgh */
  82.    &toktab[18], NULL,        NULL,        NULL,        /* 89-8C i... */
  83.    NULL,        NULL,        NULL,        NULL,        /* 8D-90 .... */
  84.    NULL,        NULL,        &toktab[21], NULL,        /* 91-94 jklm */
  85.    &toktab[23], &toktab[25], &toktab[26], NULL,        /* 95-98 nopq */
  86.    &toktab[27], NULL,        NULL,        NULL,        /* 99-9C r... */
  87.    NULL,        NULL,        NULL,        NULL,        /* 9D-A0 .... */
  88.    NULL,        &toktab[30], &toktab[32], &toktab[34], /* A1-A4 .stu */
  89.    NULL,        &toktab[35], NULL,        NULL,        /* A5-A8 vwxy */
  90.    NULL,                                               /* A9-A9 z */
  91. #endif                    /* EBCDIC */
  92.    };
  93.  
  94. /*
  95.  * The operator table acts to extend the token table, it
  96.  *  indicates what implementations are expected from rtt,
  97.  *  and it has pointers for the implementation information.
  98.  */
  99.  
  100. struct optab optab[] = {
  101.    {{"!",      BANG,       Beginner}, Unary,          NULL, NULL}, /* 0 */
  102.    {{"%",      MOD,        0},        Binary,         NULL, NULL}, /* 1 */
  103.    {{"%:=",    AUGMOD,     0},        0,              NULL, NULL}, /* 2 */
  104.    {{"&",      AND,        Beginner}, Binary,         NULL, NULL}, /* 3 */
  105.    {{"&:=",    AUGAND,     0},        0,              NULL, NULL}, /* 4 */
  106.    {{"*",      STAR,       Beginner}, Unary | Binary, NULL, NULL}, /* 5 */
  107.    {{"*:=",    AUGSTAR,    0},        0,              NULL, NULL}, /* 6 */
  108.    {{"**",     INTER,      Beginner}, Binary,         NULL, NULL}, /* 7 */
  109.    {{"**:=",   AUGINTER,   0},        0,              NULL, NULL}, /* 8 */
  110.    {{"+",      PLUS,       Beginner}, Unary | Binary, NULL, NULL}, /* 9 */
  111.    {{"+:=",    AUGPLUS,    0},        0,              NULL, NULL}, /* 10 */
  112.    {{"++",     UNION,      Beginner}, Binary,         NULL, NULL}, /* 11 */
  113.    {{"++:=",   AUGUNION,   0},        0,              NULL, NULL}, /* 12 */
  114.    {{"-",      MINUS,      Beginner}, Unary | Binary, NULL, NULL}, /* 13 */
  115.    {{"-:=",    AUGMINUS,   0},        0,              NULL, NULL}, /* 14 */
  116.    {{"--",     DIFF,       Beginner}, Binary,         NULL, NULL}, /* 15 */
  117.    {{"--:=",   AUGDIFF,    0},        0,              NULL, NULL}, /* 16 */
  118.    {{".",      DOT,        Beginner}, Unary,          NULL, NULL}, /* 17 */
  119.    {{"/",      SLASH,      Beginner}, Unary | Binary, NULL, NULL}, /* 18 */
  120.    {{"/:=",    AUGSLASH,   0},        0,              NULL, NULL}, /* 19 */
  121.    {{":=",     ASSIGN,     0},        Binary,         NULL, NULL}, /* 20 */
  122.    {{":=:",    SWAP,       0},        Binary,         NULL, NULL}, /* 21 */
  123.    {{"<",      NMLT,       0},        Binary,         NULL, NULL}, /* 22 */
  124.    {{"<:=",    AUGNMLT,    0},        0,              NULL, NULL}, /* 23 */
  125.    {{"<-",     REVASSIGN,  0},        Binary,         NULL, NULL}, /* 24 */
  126.    {{"<->",    REVSWAP,    0},        Binary,         NULL, NULL}, /* 25 */
  127.    {{"<<",     SLT,        0},        Binary,         NULL, NULL}, /* 26 */
  128.    {{"<<:=",   AUGSLT,     0},        0,              NULL, NULL}, /* 27 */
  129.    {{"<<=",    SLE,        0},        Binary,         NULL, NULL}, /* 28 */
  130.    {{"<<=:=",  AUGSLE,     0},        0,              NULL, NULL}, /* 29 */
  131.    {{"<=",     NMLE,       0},        Binary,         NULL, NULL}, /* 30 */
  132.    {{"<=:=",   AUGNMLE,    0},        0,              NULL, NULL}, /* 31 */
  133.    {{"=",      NMEQ,       Beginner}, Unary | Binary, NULL, NULL}, /* 32 */
  134.    {{"=:=",    AUGNMEQ,    0},        0,              NULL, NULL}, /* 33 */
  135.    {{"==",     SEQ,        Beginner}, Binary,         NULL, NULL}, /* 34 */
  136.    {{"==:=",   AUGSEQ,     0},        0,              NULL, NULL}, /* 35 */
  137.    {{"===",    EQUIV,      Beginner}, Binary,         NULL, NULL}, /* 36 */
  138.    {{"===:=",  AUGEQUIV,   0},        0,              NULL, NULL}, /* 37 */
  139.    {{">",      NMGT,       0},        Binary,         NULL, NULL}, /* 38 */
  140.    {{">:=",    AUGNMGT,    0},        0,              NULL, NULL}, /* 39 */
  141.    {{">=",     NMGE,       0},        Binary,         NULL, NULL}, /* 40 */
  142.    {{">=:=",   AUGNMGE,    0},        0,              NULL, NULL}, /* 41 */
  143.    {{">>",     SGT,        0},        Binary,         NULL, NULL}, /* 42 */
  144.    {{">>:=",   AUGSGT,     0},        0,              NULL, NULL}, /* 43 */
  145.    {{">>=",    SGE,        0},        Binary,         NULL, NULL}, /* 44 */
  146.    {{">>=:=",  AUGSGE,     0},        0,              NULL, NULL}, /* 45 */
  147.    {{"?",      QMARK,      Beginner}, Unary,          NULL, NULL}, /* 46 */
  148.    {{"?:=",    AUGQMARK,   0},        0,              NULL, NULL}, /* 47 */
  149.    {{"@",      AT,         Beginner}, 0,              NULL, NULL}, /* 48 */
  150.    {{"@:=",    AUGAT,      0},        0,              NULL, NULL}, /* 49 */
  151.    {{"\\",     BACKSLASH,  Beginner}, Unary,          NULL, NULL}, /* 50 */
  152.    {{"^",      CARET,      Beginner}, Unary | Binary, NULL, NULL}, /* 51 */
  153.    {{"^:=",    AUGCARET,   0},        0,              NULL, NULL}, /* 52 */
  154.    {{"|",      BAR,        Beginner}, 0,              NULL, NULL}, /* 53 */
  155.    {{"||",     CONCAT,     Beginner}, Binary,         NULL, NULL}, /* 54 */
  156.    {{"||:=",   AUGCONCAT,  0},        0,              NULL, NULL}, /* 55 */
  157.    {{"|||",    LCONCAT,    Beginner}, Binary,         NULL, NULL}, /* 56 */
  158.    {{"|||:=",  AUGLCONCAT, 0},        0,              NULL, NULL}, /* 57 */
  159.    {{"~",      TILDE,      Beginner}, Unary,          NULL, NULL}, /* 58 */
  160.    {{"~=",     NMNE,       Beginner}, Binary,         NULL, NULL}, /* 59 */
  161.    {{"~=:=",   AUGNMNE,    0},        0,              NULL, NULL}, /* 60 */
  162.    {{"~==",    SNE,        Beginner}, Binary,         NULL, NULL}, /* 61 */
  163.    {{"~==:=",  AUGSNE,     0},        0,              NULL, NULL}, /* 62 */
  164.    {{"~===",   NEQUIV,     Beginner}, Binary,         NULL, NULL}, /* 63 */
  165.    {{"~===:=", AUGNEQUIV,  0},        0,              NULL, NULL}, /* 64 */
  166.    {{"(",      LPAREN,     Beginner}, 0,              NULL, NULL}, /* 65 */
  167.    {{")",      RPAREN,     Ender},    0,              NULL, NULL}, /* 66 */
  168.    {{"+:",     PCOLON,     0},        0,              NULL, NULL}, /* 67 */
  169.    {{",",      COMMA,      0},        0,              NULL, NULL}, /* 68 */
  170.    {{"-:",     MCOLON,     0},        0,              NULL, NULL}, /* 69 */
  171.    {{":",      COLON,      0},        0,              NULL, NULL}, /* 70 */
  172.    {{";",      SEMICOL,    0},        0,              NULL, NULL}, /* 71 */
  173.    {{"[",      LBRACK,     Beginner}, 0,              NULL, NULL}, /* 72 */
  174.    {{"]",      RBRACK,     Ender},    0,              NULL, NULL}, /* 73 */
  175.    {{"{",      LBRACE,     Beginner}, 0,              NULL, NULL}, /* 74 */
  176.    {{"}",      RBRACE,     Ender},    0,              NULL, NULL}, /* 75 */
  177.    {{"$(",     LBRACE,     Beginner}, 0,              NULL, NULL}, /* 76 */
  178.    {{"$)",     RBRACE,     Ender},    0,              NULL, NULL}, /* 77 */
  179.    {{"$<",     LBRACK,     Beginner}, 0,              NULL, NULL}, /* 78 */
  180.    {{"$>",     RBRACK,     Ender},    0,              NULL, NULL}, /* 79 */
  181.    {{NULL,          0,     0},        0,              NULL, NULL}
  182.    };
  183.  
  184. int asgn_loc = 20;
  185. int semicol_loc = 71;
  186. int plus_loc = 9;
  187. int minus_loc = 13;
  188.  
  189. /*
  190.  * getopr - find the longest legal operator and return the
  191.  *  index to its entry in the operator table.
  192.  */
  193.  
  194. int getopr(ac, cc)
  195. int ac;
  196. int *cc;
  197.    {
  198.    register char c;
  199.  
  200.    *cc = ' ';
  201.    switch (c = ac) {
  202.       case '!':
  203.          return 0;   /* ! */
  204.       case '$':
  205.          switch (c = NextChar) {
  206.             case '(':
  207.                return 76;   /* $( */
  208.             case ')':
  209.                return 77;   /* $) */
  210.             case '<':
  211.                return 78;   /* $< */
  212.             case '>':
  213.                return 79;   /* $> */
  214.             }
  215.          break;
  216.       case '%':
  217.          if ((c = NextChar) == ':') {
  218.             if ((c = NextChar) == '=') {
  219.                return 2;   /* %:= */
  220.                }
  221.             }
  222.          else {
  223.             *cc = c;
  224.             return 1;   /* % */
  225.             }
  226.          break;
  227.       case '&':
  228.          if ((c = NextChar) == ':') {
  229.             if ((c = NextChar) == '=') {
  230.                return 4;   /* &:= */
  231.                }
  232.             }
  233.          else {
  234.             *cc = c;
  235.             return 3;   /* & */
  236.             }
  237.          break;
  238.       case '(':
  239.          return 65;   /* ( */
  240.       case ')':
  241.          return 66;   /* ) */
  242.       case '*':
  243.          switch (c = NextChar) {
  244.             case '*':
  245.                if ((c = NextChar) == ':') {
  246.                   if ((c = NextChar) == '=') {
  247.                      return 8;   /* **:= */
  248.                      }
  249.                   }
  250.                else {
  251.                   *cc = c;
  252.                   return 7;   /* ** */
  253.                   }
  254.                break;
  255.             case ':':
  256.                if ((c = NextChar) == '=') {
  257.                   return 6;   /* *:= */
  258.                   }
  259.                break;
  260.             default:
  261.                *cc = c;
  262.                return 5;   /* * */
  263.             }
  264.          break;
  265.       case '+':
  266.          switch (c = NextChar) {
  267.             case '+':
  268.                if ((c = NextChar) == ':') {
  269.                   if ((c = NextChar) == '=') {
  270.                      return 12;   /* ++:= */
  271.                      }
  272.                   }
  273.                else {
  274.                   *cc = c;
  275.                   return 11;   /* ++ */
  276.                   }
  277.                break;
  278.             case ':':
  279.                if ((c = NextChar) == '=') {
  280.                   return 10;   /* +:= */
  281.                   }
  282.                else {
  283.                   *cc = c;
  284.                   return 67;   /* +: */
  285.                   }
  286.             default:
  287.                *cc = c;
  288.                return 9;   /* + */
  289.             }
  290.          break;
  291.       case ',':
  292.          return 68;   /* , */
  293.       case '-':
  294.          switch (c = NextChar) {
  295.             case '-':
  296.                if ((c = NextChar) == ':') {
  297.                   if ((c = NextChar) == '=') {
  298.                      return 16;   /* --:= */
  299.                      }
  300.                   }
  301.                else {
  302.                   *cc = c;
  303.                   return 15;   /* -- */
  304.                   }
  305.                break;
  306.             case ':':
  307.                if ((c = NextChar) == '=') {
  308.                   return 14;   /* -:= */
  309.                   }
  310.                else {
  311.                   *cc = c;
  312.                   return 69;   /* -: */
  313.                   }
  314.             default:
  315.                *cc = c;
  316.                return 13;   /* - */
  317.             }
  318.          break;
  319.       case '.':
  320.          return 17;   /* . */
  321.       case '/':
  322.          if ((c = NextChar) == ':') {
  323.             if ((c = NextChar) == '=') {
  324.                return 19;   /* /:= */
  325.                }
  326.             }
  327.          else {
  328.             *cc = c;
  329.             return 18;   /* / */
  330.             }
  331.          break;
  332.       case ':':
  333.          if ((c = NextChar) == '=') {
  334.             if ((c = NextChar) == ':') {
  335.                return 21;   /* :=: */
  336.                }
  337.             else {
  338.                *cc = c;
  339.                return 20;   /* := */
  340.                }
  341.             }
  342.          else {
  343.             *cc = c;
  344.             return 70;   /* : */
  345.             }
  346.       case ';':
  347.          return 71;   /* ; */
  348.       case '<':
  349.          switch (c = NextChar) {
  350.             case '-':
  351.                if ((c = NextChar) == '>') {
  352.                   return 25;   /* <-> */
  353.                   }
  354.                else {
  355.                   *cc = c;
  356.                   return 24;   /* <- */
  357.                   }
  358.             case ':':
  359.                if ((c = NextChar) == '=') {
  360.                   return 23;   /* <:= */
  361.                   }
  362.                break;
  363.             case '<':
  364.                switch (c = NextChar) {
  365.                   case ':':
  366.                      if ((c = NextChar) == '=') {
  367.                         return 27;   /* <<:= */
  368.                         }
  369.                      break;
  370.                   case '=':
  371.                      if ((c = NextChar) == ':') {
  372.                         if ((c = NextChar) == '=') {
  373.                            return 29;   /* <<=:= */
  374.                            }
  375.                         }
  376.                      else {
  377.                         *cc = c;
  378.                         return 28;   /* <<= */
  379.                         }
  380.                      break;
  381.                   default:
  382.                      *cc = c;
  383.                      return 26;   /* << */
  384.                   }
  385.                break;
  386.             case '=':
  387.                if ((c = NextChar) == ':') {
  388.                   if ((c = NextChar) == '=') {
  389.                      return 31;   /* <=:= */
  390.                      }
  391.                   }
  392.                else {
  393.                   *cc = c;
  394.                   return 30;   /* <= */
  395.                   }
  396.                break;
  397.             default:
  398.                *cc = c;
  399.                return 22;   /* < */
  400.             }
  401.          break;
  402.       case '=':
  403.          switch (c = NextChar) {
  404.             case ':':
  405.                if ((c = NextChar) == '=') {
  406.                   return 33;   /* =:= */
  407.                   }
  408.                break;
  409.             case '=':
  410.                switch (c = NextChar) {
  411.                   case ':':
  412.                      if ((c = NextChar) == '=') {
  413.                         return 35;   /* ==:= */
  414.                         }
  415.                      break;
  416.                   case '=':
  417.                      if ((c = NextChar) == ':') {
  418.                         if ((c = NextChar) == '=') {
  419.                            return 37;   /* ===:= */
  420.                            }
  421.                         }
  422.                      else {
  423.                         *cc = c;
  424.                         return 36;   /* === */
  425.                         }
  426.                      break;
  427.                   default:
  428.                      *cc = c;
  429.                      return 34;   /* == */
  430.                   }
  431.                break;
  432.             default:
  433.                *cc = c;
  434.                return 32;   /* = */
  435.             }
  436.          break;
  437.       case '>':
  438.          switch (c = NextChar) {
  439.             case ':':
  440.                if ((c = NextChar) == '=') {
  441.                   return 39;   /* >:= */
  442.                   }
  443.                break;
  444.             case '=':
  445.                if ((c = NextChar) == ':') {
  446.                   if ((c = NextChar) == '=') {
  447.                      return 41;   /* >=:= */
  448.                      }
  449.                   }
  450.                else {
  451.                   *cc = c;
  452.                   return 40;   /* >= */
  453.                   }
  454.                break;
  455.             case '>':
  456.                switch (c = NextChar) {
  457.                   case ':':
  458.                      if ((c = NextChar) == '=') {
  459.                         return 43;   /* >>:= */
  460.                         }
  461.                      break;
  462.                   case '=':
  463.                      if ((c = NextChar) == ':') {
  464.                         if ((c = NextChar) == '=') {
  465.                            return 45;   /* >>=:= */
  466.                            }
  467.                         }
  468.                      else {
  469.                         *cc = c;
  470.                         return 44;   /* >>= */
  471.                         }
  472.                      break;
  473.                   default:
  474.                      *cc = c;
  475.                      return 42;   /* >> */
  476.                   }
  477.                break;
  478.             default:
  479.                *cc = c;
  480.                return 38;   /* > */
  481.             }
  482.          break;
  483.       case '?':
  484.          if ((c = NextChar) == ':') {
  485.             if ((c = NextChar) == '=') {
  486.                return 47;   /* ?:= */
  487.                }
  488.             }
  489.          else {
  490.             *cc = c;
  491.             return 46;   /* ? */
  492.             }
  493.          break;
  494.       case '@':
  495.          if ((c = NextChar) == ':') {
  496.             if ((c = NextChar) == '=') {
  497.                return 49;   /* @:= */
  498.                }
  499.             }
  500.          else {
  501.             *cc = c;
  502.             return 48;   /* @ */
  503.             }
  504.          break;
  505.       case '[':
  506.          return 72;   /* [ */
  507.       case '\\':
  508.          return 50;   /* \ */
  509.       case ']':
  510.          return 73;   /* ] */
  511.       case '^':
  512.          if ((c = NextChar) == ':') {
  513.             if ((c = NextChar) == '=') {
  514.                return 52;   /* ^:= */
  515.                }
  516.             }
  517.          else {
  518.             *cc = c;
  519.             return 51;   /* ^ */
  520.             }
  521.          break;
  522.       case '{':
  523.          return 74;   /* { */
  524.       case '|':
  525.          if ((c = NextChar) == '|') {
  526.             switch (c = NextChar) {
  527.                case ':':
  528.                   if ((c = NextChar) == '=') {
  529.                      return 55;   /* ||:= */
  530.                      }
  531.                   break;
  532.                case '|':
  533.                   if ((c = NextChar) == ':') {
  534.                      if ((c = NextChar) == '=') {
  535.                         return 57;   /* |||:= */
  536.                         }
  537.                      }
  538.                   else {
  539.                      *cc = c;
  540.                      return 56;   /* ||| */
  541.                      }
  542.                   break;
  543.                default:
  544.                   *cc = c;
  545.                   return 54;   /* || */
  546.                }
  547.             }
  548.          else {
  549.             *cc = c;
  550.             return 53;   /* | */
  551.             }
  552.          break;
  553.       case '}':
  554.          return 75;   /* } */
  555.       case '~':
  556.          if ((c = NextChar) == '=') {
  557.             switch (c = NextChar) {
  558.                case ':':
  559.                   if ((c = NextChar) == '=') {
  560.                      return 60;   /* ~=:= */
  561.                      }
  562.                   break;
  563.                case '=':
  564.                   switch (c = NextChar) {
  565.                      case ':':
  566.                         if ((c = NextChar) == '=') {
  567.                            return 62;   /* ~==:= */
  568.                            }
  569.                         break;
  570.                      case '=':
  571.                         if ((c = NextChar) == ':') {
  572.                            if ((c = NextChar) == '=') {
  573.                               return 64;   /* ~===:= */
  574.                               }
  575.                            }
  576.                         else {
  577.                            *cc = c;
  578.                            return 63;   /* ~=== */
  579.                            }
  580.                         break;
  581.                      default:
  582.                         *cc = c;
  583.                         return 61;   /* ~== */
  584.                      }
  585.                   break;
  586.                default:
  587.                   *cc = c;
  588.                   return 59;   /* ~= */
  589.                }
  590.             }
  591.          else {
  592.             *cc = c;
  593.             return 58;   /* ~ */
  594.             }
  595.          break;
  596.       }
  597.    tfatal("invalid character", (char *)NULL);
  598.    return -1;
  599.    }
  600.